home *** CD-ROM | disk | FTP | other *** search
/ Amiga Plus 2004 #9 / Amiga Plus CD - 2004 - No. 09.iso / amigaplus / tools / amigaos4_only / mpega_libmad / mad / frame.c < prev    next >
C/C++ Source or Header  |  2004-08-03  |  12KB  |  505 lines
  1. /*
  2.  * libmad - MPEG audio decoder library
  3.  * Copyright (C) 2000-2004 Underbit Technologies, Inc.
  4.  *
  5.  * This program is free software; you can redistribute it and/or modify
  6.  * it under the terms of the GNU General Public License as published by
  7.  * the Free Software Foundation; either version 2 of the License, or
  8.  * (at your option) any later version.
  9.  *
  10.  * This program is distributed in the hope that it will be useful,
  11.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13.  * GNU General Public License for more details.
  14.  *
  15.  * You should have received a copy of the GNU General Public License
  16.  * along with this program; if not, write to the Free Software
  17.  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18.  *
  19.  * $Id: frame.c,v 1.29 2004/02/04 22:59:19 rob Exp $
  20.  */
  21.  
  22. # ifdef HAVE_CONFIG_H
  23. #  include "config.h"
  24. # endif
  25.  
  26. # include "global.h"
  27.  
  28. # include <stdlib.h>
  29. # include <string.h>
  30.  
  31. # include "bit.h"
  32. # include "stream.h"
  33. # include "frame.h"
  34. # include "timer.h"
  35. # include "layer12.h"
  36. # include "layer3.h"
  37.  
  38. static
  39. unsigned long const bitrate_table[5][15] = {
  40.   /* MPEG-1 */
  41.   { 0,  32000,  64000,  96000, 128000, 160000, 192000, 224000,  /* Layer I   */
  42.        256000, 288000, 320000, 352000, 384000, 416000, 448000 },
  43.   { 0,  32000,  48000,  56000,  64000,  80000,  96000, 112000,  /* Layer II  */
  44.        128000, 160000, 192000, 224000, 256000, 320000, 384000 },
  45.   { 0,  32000,  40000,  48000,  56000,  64000,  80000,  96000,  /* Layer III */
  46.        112000, 128000, 160000, 192000, 224000, 256000, 320000 },
  47.  
  48.   /* MPEG-2 LSF */
  49.   { 0,  32000,  48000,  56000,  64000,  80000,  96000, 112000,  /* Layer I   */
  50.        128000, 144000, 160000, 176000, 192000, 224000, 256000 },
  51.   { 0,   8000,  16000,  24000,  32000,  40000,  48000,  56000,  /* Layers    */
  52.         64000,  80000,  96000, 112000, 128000, 144000, 160000 } /* II & III  */
  53. };
  54.  
  55. static
  56. unsigned int const samplerate_table[3] = { 44100, 48000, 32000 };
  57.  
  58. static
  59. int (*const decoder_table[3])(struct mad_stream *, struct mad_frame *) = {
  60.   mad_layer_I,
  61.   mad_layer_II,
  62.   mad_layer_III
  63. };
  64.  
  65. /*
  66.  * NAME:    header->init()
  67.  * DESCRIPTION:    initialize header struct
  68.  */
  69. void mad_header_init(struct mad_header *header)
  70. {
  71.   header->layer          = 0;
  72.   header->mode           = 0;
  73.   header->mode_extension = 0;
  74.   header->emphasis       = 0;
  75.  
  76.   header->bitrate        = 0;
  77.   header->samplerate     = 0;
  78.  
  79.   header->crc_check      = 0;
  80.   header->crc_target     = 0;
  81.  
  82.   header->flags          = 0;
  83.   header->private_bits   = 0;
  84.  
  85.   header->duration       = mad_timer_zero;
  86. }
  87.  
  88. /*
  89.  * NAME:    frame->init()
  90.  * DESCRIPTION:    initialize frame struct
  91.  */
  92. void mad_frame_init(struct mad_frame *frame)
  93. {
  94.   mad_header_init(&frame->header);
  95.  
  96.   frame->options = 0;
  97.  
  98.   frame->overlap = 0;
  99.   mad_frame_mute(frame);
  100. }
  101.  
  102. /*
  103.  * NAME:    frame->finish()
  104.  * DESCRIPTION:    deallocate any dynamic memory associated with frame
  105.  */
  106. void mad_frame_finish(struct mad_frame *frame)
  107. {
  108.   mad_header_finish(&frame->header);
  109.  
  110.   if (frame->overlap) {
  111.     free(frame->overlap);
  112.     frame->overlap = 0;
  113.   }
  114. }
  115.  
  116. /*
  117.  * NAME:    decode_header()
  118.  * DESCRIPTION:    read header data and following CRC word
  119.  */
  120. static
  121. int decode_header(struct mad_header *header, struct mad_stream *stream)
  122. {
  123.   unsigned int index;
  124.  
  125.   header->flags        = 0;
  126.   header->private_bits = 0;
  127.  
  128.   /* header() */
  129.  
  130.   /* syncword */
  131.   mad_bit_skip(&stream->ptr, 11);
  132.  
  133.   /* MPEG 2.5 indicator (really part of syncword) */
  134.   if (mad_bit_read(&stream->ptr, 1) == 0)
  135.     header->flags |= MAD_FLAG_MPEG_2_5_EXT;
  136.  
  137.   /* ID */
  138.   if (mad_bit_read(&stream->ptr, 1) == 0)
  139.     header->flags |= MAD_FLAG_LSF_EXT;
  140.   else if (header->flags & MAD_FLAG_MPEG_2_5_EXT) {
  141.     stream->error = MAD_ERROR_LOSTSYNC;
  142.     return -1;
  143.   }
  144.  
  145.   /* layer */
  146.   header->layer = 4 - mad_bit_read(&stream->ptr, 2);
  147.  
  148.   if (header->layer == 4) {
  149.     stream->error = MAD_ERROR_BADLAYER;
  150.     return -1;
  151.   }
  152.  
  153.   /* protection_bit */
  154.   if (mad_bit_read(&stream->ptr, 1) == 0) {
  155.     header->flags    |= MAD_FLAG_PROTECTION;
  156.     header->crc_check = mad_bit_crc(stream->ptr, 16, 0xffff);
  157.   }
  158.  
  159.   /* bitrate_index */
  160.   index = mad_bit_read(&stream->ptr, 4);
  161.  
  162.   if (index == 15) {
  163.     stream->error = MAD_ERROR_BADBITRATE;
  164.     return -1;
  165.   }
  166.  
  167.   if (header->flags & MAD_FLAG_LSF_EXT)
  168.     header->bitrate = bitrate_table[3 + (header->layer >> 1)][index];
  169.   else
  170.     header->bitrate = bitrate_table[header->layer - 1][index];
  171.  
  172.   /* sampling_frequency */
  173.   index = mad_bit_read(&stream->ptr, 2);
  174.  
  175.   if (index == 3) {
  176.     stream->error = MAD_ERROR_BADSAMPLERATE;
  177.     return -1;
  178.   }
  179.  
  180.   header->samplerate = samplerate_table[index];
  181.  
  182.   if (header->flags & MAD_FLAG_LSF_EXT) {
  183.     header->samplerate /= 2;
  184.  
  185.     if (header->flags & MAD_FLAG_MPEG_2_5_EXT)
  186.       header->samplerate /= 2;
  187.   }
  188.  
  189.   /* padding_bit */
  190.   if (mad_bit_read(&stream->ptr, 1))
  191.     header->flags |= MAD_FLAG_PADDING;
  192.  
  193.   /* private_bit */
  194.   if (mad_bit_read(&stream->ptr, 1))
  195.     header->private_bits |= MAD_PRIVATE_HEADER;
  196.  
  197.   /* mode */
  198.   header->mode = 3 - mad_bit_read(&stream->ptr, 2);
  199.  
  200.   /* mode_extension */
  201.   header->mode_extension = mad_bit_read(&stream->ptr, 2);
  202.  
  203.   /* copyright */
  204.   if (mad_bit_read(&stream->ptr, 1))
  205.     header->flags |= MAD_FLAG_COPYRIGHT;
  206.  
  207.   /* original/copy */
  208.   if (mad_bit_read(&stream->ptr, 1))
  209.     header->flags |= MAD_FLAG_ORIGINAL;
  210.  
  211.   /* emphasis */
  212.   header->emphasis = mad_bit_read(&stream->ptr, 2);
  213.  
  214. # if defined(OPT_STRICT)
  215.   /*
  216.    * ISO/IEC 11172-3 says this is a reserved emphasis value, but
  217.    * streams exist which use it anyway. Since the value is not important
  218.    * to the decoder proper, we allow it unless OPT_STRICT is defined.
  219.    */
  220.   if (header->emphasis == MAD_EMPHASIS_RESERVED) {
  221.     stream->error = MAD_ERROR_BADEMPHASIS;
  222.     return -1;
  223.   }
  224. # endif
  225.  
  226.   /* error_check() */
  227.  
  228.   /* crc_check */
  229.   if (header->flags & MAD_FLAG_PROTECTION)
  230.     header->crc_target = mad_bit_read(&stream->ptr, 16);
  231.  
  232.   return 0;
  233. }
  234.  
  235. /*
  236.  * NAME:    free_bitrate()
  237.  * DESCRIPTION:    attempt to discover the bitstream's free bitrate
  238.  */
  239. static
  240. int free_bitrate(struct mad_stream *stream, struct mad_header const *header)
  241. {
  242.   struct mad_bitptr keep_ptr;
  243.   unsigned long rate = 0;
  244.   unsigned int pad_slot, slots_per_frame;
  245.   unsigned char const *ptr = 0;
  246.  
  247.   keep_ptr = stream->ptr;
  248.  
  249.   pad_slot = (header->flags & MAD_FLAG_PADDING) ? 1 : 0;
  250.   slots_per_frame = (header->layer == MAD_LAYER_III &&
  251.              (header->flags & MAD_FLAG_LSF_EXT)) ? 72 : 144;
  252.  
  253.   while (mad_stream_sync(stream) == 0) {
  254.     struct mad_stream peek_stream;
  255.     struct mad_header peek_header;
  256.  
  257.     bcopy(stream, &peek_stream, sizeof(*stream));
  258.     bcopy(header, &peek_header, sizeof(*header));
  259.  
  260.     if (decode_header(&peek_header, &peek_stream) == 0 &&
  261.     peek_header.layer == header->layer &&
  262.     peek_header.samplerate == header->samplerate) {
  263.       unsigned int N;
  264.  
  265.       ptr = mad_bit_nextbyte(&stream->ptr);
  266.  
  267.       N = ptr - stream->this_frame;
  268.  
  269.       if (header->layer == MAD_LAYER_I) {
  270.     rate = (unsigned long) header->samplerate *
  271.       (N - 4 * pad_slot + 4) / 48 / 1000;
  272.       }
  273.       else {
  274.     rate = (unsigned long) header->samplerate *
  275.       (N - pad_slot + 1) / slots_per_frame / 1000;
  276.       }
  277.  
  278.       if (rate >= 8)
  279.     break;
  280.     }
  281.  
  282.     mad_bit_skip(&stream->ptr, 8);
  283.   }
  284.  
  285.   stream->ptr = keep_ptr;
  286.  
  287.   if (rate < 8 || (header->layer == MAD_LAYER_III && rate > 640)) {
  288.     stream->error = MAD_ERROR_LOSTSYNC;
  289.     return -1;
  290.   }
  291.  
  292.   stream->freerate = rate * 1000;
  293.  
  294.   return 0;
  295. }
  296.  
  297. /*
  298.  * NAME:    header->decode()
  299.  * DESCRIPTION:    read the next frame header from the stream
  300.  */
  301. int mad_header_decode(struct mad_header *header, struct mad_stream *stream)
  302. {
  303.   register unsigned char const *ptr, *end;
  304.   unsigned int pad_slot, N;
  305.  
  306.   ptr = stream->next_frame;
  307.   end = stream->bufend;
  308.  
  309.   if (ptr == 0) {
  310.     stream->error = MAD_ERROR_BUFPTR;
  311.     goto fail;
  312.   }
  313.  
  314.   /* stream skip */
  315.   if (stream->skiplen) {
  316.     if (!stream->sync)
  317.       ptr = stream->this_frame;
  318.  
  319.     if (end - ptr < stream->skiplen) {
  320.       stream->skiplen   -= end - ptr;
  321.       stream->next_frame = end;
  322.  
  323.       stream->error = MAD_ERROR_BUFLEN;
  324.       goto fail;
  325.     }
  326.  
  327.     ptr += stream->skiplen;
  328.     stream->skiplen = 0;
  329.  
  330.     stream->sync = 1;
  331.   }
  332.  
  333.  sync:
  334.   /* synchronize */
  335.   if (stream->sync) {
  336.     if (end - ptr < MAD_BUFFER_GUARD) {
  337.       stream->next_frame = ptr;
  338.  
  339.       stream->error = MAD_ERROR_BUFLEN;
  340.       goto fail;
  341.     }
  342.     else if (!(ptr[0] == 0xff && (ptr[1] & 0xe0) == 0xe0)) {
  343.       /* mark point where frame sync word was expected */
  344.       stream->this_frame = ptr;
  345.       stream->next_frame = ptr + 1;
  346.  
  347.       stream->error = MAD_ERROR_LOSTSYNC;
  348.       goto fail;
  349.     }
  350.   }
  351.   else {
  352.     mad_bit_init(&stream->ptr, ptr);
  353.  
  354.     if (mad_stream_sync(stream) == -1) {
  355.       if (end - stream->next_frame >= MAD_BUFFER_GUARD)
  356.     stream->next_frame = end - MAD_BUFFER_GUARD;
  357.  
  358.       stream->error = MAD_ERROR_BUFLEN;
  359.       goto fail;
  360.     }
  361.  
  362.     ptr = mad_bit_nextbyte(&stream->ptr);
  363.   }
  364.  
  365.   /* begin processing */
  366.   stream->this_frame = ptr;
  367.   stream->next_frame = ptr + 1;  /* possibly bogus sync word */
  368.  
  369.   mad_bit_init(&stream->ptr, stream->this_frame);
  370.  
  371.   if (decode_header(header, stream) == -1)
  372.     goto fail;
  373.  
  374.   /* calculate frame duration */
  375.   mad_timer_set(&header->duration, 0,
  376.         32 * MAD_NSBSAMPLES(header), header->samplerate);
  377.  
  378.   /* calculate free bit rate */
  379.   if (header->bitrate == 0) {
  380.     if ((stream->freerate == 0 || !stream->sync ||
  381.      (header->layer == MAD_LAYER_III && stream->freerate > 640000)) &&
  382.     free_bitrate(stream, header) == -1)
  383.       goto fail;
  384.  
  385.     header->bitrate = stream->freerate;
  386.     header->flags  |= MAD_FLAG_FREEFORMAT;
  387.   }
  388.  
  389.   /* calculate beginning of next frame */
  390.   pad_slot = (header->flags & MAD_FLAG_PADDING) ? 1 : 0;
  391.  
  392.   if (header->layer == MAD_LAYER_I)
  393.     N = ((12 * header->bitrate / header->samplerate) + pad_slot) * 4;
  394.   else {
  395.     unsigned int slots_per_frame;
  396.  
  397.     slots_per_frame = (header->layer == MAD_LAYER_III &&
  398.                (header->flags & MAD_FLAG_LSF_EXT)) ? 72 : 144;
  399.  
  400.     N = (slots_per_frame * header->bitrate / header->samplerate) + pad_slot;
  401.   }
  402.  
  403.   /* verify there is enough data left in buffer to decode this frame */
  404.   if (N + MAD_BUFFER_GUARD > end - stream->this_frame) {
  405.     stream->next_frame = stream->this_frame;
  406.  
  407.     stream->error = MAD_ERROR_BUFLEN;
  408.     goto fail;
  409.   }
  410.  
  411.   stream->next_frame = stream->this_frame + N;
  412.  
  413.   if (!stream->sync) {
  414.     /* check that a valid frame header follows this frame */
  415.  
  416.     ptr = stream->next_frame;
  417.     if (!(ptr[0] == 0xff && (ptr[1] & 0xe0) == 0xe0)) {
  418.       ptr = stream->next_frame = stream->this_frame + 1;
  419.       goto sync;
  420.     }
  421.  
  422.     stream->sync = 1;
  423.   }
  424.  
  425.   header->flags |= MAD_FLAG_INCOMPLETE;
  426.  
  427.   return 0;
  428.  
  429.  fail:
  430.   stream->sync = 0;
  431.  
  432.   return -1;
  433. }
  434.  
  435. /*
  436.  * NAME:    frame->decode()
  437.  * DESCRIPTION:    decode a single frame from a bitstream
  438.  */
  439. int mad_frame_decode(struct mad_frame *frame, struct mad_stream *stream)
  440. {
  441.   frame->options = stream->options;
  442.  
  443.   /* header() */
  444.   /* error_check() */
  445.  
  446.   if (!(frame->header.flags & MAD_FLAG_INCOMPLETE) &&
  447.       mad_header_decode(&frame->header, stream) == -1)
  448.     goto fail;
  449.  
  450.   /* audio_data() */
  451.  
  452.   frame->header.flags &= ~MAD_FLAG_INCOMPLETE;
  453.  
  454.   if (decoder_table[frame->header.layer - 1](stream, frame) == -1) {
  455.     if (!MAD_RECOVERABLE(stream->error))
  456.       stream->next_frame = stream->this_frame;
  457.  
  458.     goto fail;
  459.   }
  460.  
  461.   /* ancillary_data() */
  462.  
  463.   if (frame->header.layer != MAD_LAYER_III) {
  464.     struct mad_bitptr next_frame;
  465.  
  466.     mad_bit_init(&next_frame, stream->next_frame);
  467.  
  468.     stream->anc_ptr    = stream->ptr;
  469.     stream->anc_bitlen = mad_bit_length(&stream->ptr, &next_frame);
  470.  
  471.     mad_bit_finish(&next_frame);
  472.   }
  473.  
  474.   return 0;
  475.  
  476.  fail:
  477.   stream->anc_bitlen = 0;
  478.   return -1;
  479. }
  480.  
  481. /*
  482.  * NAME:    frame->mute()
  483.  * DESCRIPTION:    zero all subband values so the frame becomes silent
  484.  */
  485. void mad_frame_mute(struct mad_frame *frame)
  486. {
  487.   unsigned int s, sb;
  488.  
  489.   for (s = 0; s < 36; ++s) {
  490.     for (sb = 0; sb < 32; ++sb) {
  491.       frame->sbsample[0][s][sb] =
  492.       frame->sbsample[1][s][sb] = 0;
  493.     }
  494.   }
  495.  
  496.   if (frame->overlap) {
  497.     for (s = 0; s < 18; ++s) {
  498.       for (sb = 0; sb < 32; ++sb) {
  499.     (*frame->overlap)[0][sb][s] =
  500.     (*frame->overlap)[1][sb][s] = 0;
  501.       }
  502.     }
  503.   }
  504. }
  505.